home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / PInterfaces / TextEdit.p < prev    next >
Encoding:
Text File  |  1994-11-11  |  26.7 KB  |  792 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        TextEdit.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a3  ETO #16, MPW prerelease.  Friday, November 11, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT TextEdit;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __TEXTEDIT__}
  27. {$SETC __TEXTEDIT__ := 1}
  28.  
  29. {$I+}
  30. {$SETC TextEditIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __QUICKDRAW__}
  35. {$I Quickdraw.p}
  36. {$ENDC}
  37. {    Types.p                                                        }
  38. {        ConditionalMacros.p                                        }
  39. {    MixedMode.p                                                    }
  40. {    QuickdrawText.p                                                }
  41.  
  42. {$PUSH}
  43. {$ALIGN MAC68K}
  44. {$LibExport+}
  45.     
  46. TYPE
  47.     TEPtr = ^TERec;
  48.     TEHandle = ^TEPtr;
  49.  
  50. {
  51.     The following ProcPtrs cannot be written in or called from a high-level 
  52.     language without the help of mixed mode or assembly glue because they 
  53.     use the following parameter-passing conventions:
  54.  
  55.     typedef pascal void (*HighHookProcPtr)(const Rect *r, TEPtr pTE);
  56.     typedef pascal void (*CaretHookProcPtr)(const Rect *r, TEPtr pTE);
  57.  
  58.         In:
  59.             =>     r                        on stack
  60.             =>    pTE                        A3.L
  61.         Out:
  62.             none
  63.  
  64.     typedef pascal Boolean (*EOLHookProcPtr)(char theChar, TEPtr pTE, TEHandle hTE);
  65.  
  66.         In:
  67.             =>     theChar                    D0.B
  68.             =>    pTE                        A3.L
  69.             =>    hTE                        A4.L
  70.         Out:
  71.             <=    Boolean                    Z bit of the CCR
  72.  
  73.     typedef pascal unsigned short (*WidthHookProcPtr)(unsigned short textLen,
  74.      unsigned short textOffset, void *textBufferPtr, TEPtr pTE, TEHandle hTE);
  75.     typedef pascal unsigned short (*TextWidthHookProcPtr)(unsigned short textLen,
  76.      unsigned short textOffset, void *textBufferPtr, TEPtr pTE, TEHandle hTE);
  77.  
  78.         In:
  79.             =>     textLen                    D0.W
  80.             =>    textOffset                D1.W
  81.             =>    textBufferPtr            A0.L
  82.             =>    pTE                        A3.L
  83.             =>    hTE                        A4.L
  84.         Out:
  85.             <=    unsigned short            D1.W
  86.  
  87.     typedef pascal unsigned short (*NWidthHookProcPtr)(unsigned short styleRunLen,
  88.      unsigned short styleRunOffset, short slop, short direction, void *textBufferPtr, 
  89.      short *lineStart, TEPtr pTE, TEHandle hTE);
  90.  
  91.         In:
  92.             =>     styleRunLen                D0.W
  93.             =>    styleRunOffset            D1.W
  94.             =>    slop                    D2.W (low)
  95.             =>    direction                D2.W (high)
  96.             =>    textBufferPtr            A0.L
  97.             =>    lineStart                A2.L
  98.             =>    pTE                        A3.L
  99.             =>    hTE                        A4.L
  100.         Out:
  101.             <=    unsigned short            D1.W
  102.  
  103.     typedef pascal void (*DrawHookProcPtr)(unsigned short textOffset, unsigned short drawLen,
  104.      void *textBufferPtr, TEPtr pTE, TEHandle hTE);
  105.  
  106.         In:
  107.             =>     textOffset                D0.W
  108.             =>    drawLen                    D1.W
  109.             =>    textBufferPtr            A0.L
  110.             =>    pTE                        A3.L
  111.             =>    hTE                        A4.L
  112.         Out:
  113.             none
  114.  
  115.     typedef pascal Boolean (*HitTestHookProcPtr)(unsigned short styleRunLen,
  116.      unsigned short styleRunOffset, unsigned short slop, void *textBufferPtr,
  117.      TEPtr pTE, TEHandle hTE, unsigned short *pixelWidth, unsigned short *charOffset, 
  118.      Boolean *pixelInChar);
  119.  
  120.         In:
  121.             =>     styleRunLen                D0.W
  122.             =>    styleRunOffset            D1.W
  123.             =>    slop                    D2.W
  124.             =>    textBufferPtr            A0.L
  125.             =>    pTE                        A3.L
  126.             =>    hTE                        A4.L
  127.         Out:
  128.             <=    pixelWidth                D0.W (low)
  129.             <=    Boolean                    D0.W (high)
  130.             <=    charOffset                D1.W
  131.             <=    pixelInChar                D2.W
  132.  
  133.     typedef pascal void (*TEFindWordProcPtr)(unsigned short currentPos, short caller, 
  134.      TEPtr pTE, TEHandle hTE, unsigned short *wordStart, unsigned short *wordEnd);
  135.  
  136.         In:
  137.             =>     currentPos                D0.W
  138.             =>    caller                    D2.W
  139.             =>    pTE                        A3.L
  140.             =>    hTE                        A4.L
  141.         Out:
  142.             <=    wordStart                D0.W
  143.             <=    wordEnd                    D1.W
  144.  
  145.     typedef pascal void (*TERecalcProcPtr)(TEPtr pTE, unsigned short changeLength,
  146.        unsigned short *lineStart, unsigned short *firstChar, unsigned short *lastChar);
  147.  
  148.         In:
  149.             =>     pTE                        A3.L
  150.             =>    changeLength            D7.W
  151.         Out:
  152.             <=    lineStart                D2.W
  153.             <=    firstChar                D3.W
  154.             <=    lastChar                D4.W
  155.  
  156.     typedef pascal void (*TEDoTextProcPtr)(TEPtr pTE, unsigned short firstChar, unsigned short lastChar,
  157.                          short selector, GrafPtr *currentGrafPort, short *charPosition);
  158.  
  159.         In:
  160.             =>     pTE                        A3.L
  161.             =>    firstChar                D3.W
  162.             =>    lastChar                D4.W
  163.             =>    selector                D7.W
  164.         Out:
  165.             <=    currentGrafPort            A0.L
  166.             <=    charPosition            D0.W
  167.             
  168. }
  169.     HighHookProcPtr = ProcPtr;  { PROCEDURE HighHook((CONST)VAR r: Rect; pTE: TEPtr); }
  170.     EOLHookProcPtr = ProcPtr;  { FUNCTION EOLHook(theChar: ByteParameter; pTE: TEPtr; hTE: TEHandle): BOOLEAN; }
  171.     CaretHookProcPtr = ProcPtr;  { PROCEDURE CaretHook((CONST)VAR r: Rect; pTE: TEPtr); }
  172.     WidthHookProcPtr = ProcPtr;  { FUNCTION WidthHook(textLen: INTEGER; textOffset: INTEGER; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle): INTEGER; }
  173.     TextWidthHookProcPtr = ProcPtr;  { FUNCTION TextWidthHook(textLen: INTEGER; textOffset: INTEGER; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle): INTEGER; }
  174.     NWidthHookProcPtr = ProcPtr;  { FUNCTION NWidthHook(styleRunLen: INTEGER; styleRunOffset: INTEGER; slop: INTEGER; direction: INTEGER; textBufferPtr: UNIV Ptr; VAR lineStart: INTEGER; pTE: TEPtr; hTE: TEHandle): INTEGER; }
  175.     DrawHookProcPtr = ProcPtr;  { PROCEDURE DrawHook(textOffset: INTEGER; drawLen: INTEGER; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle); }
  176.     HitTestHookProcPtr = ProcPtr;  { FUNCTION HitTestHook(styleRunLen: INTEGER; styleRunOffset: INTEGER; slop: INTEGER; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle; VAR pixelWidth: INTEGER; VAR charOffset: INTEGER; VAR pixelInChar: BOOLEAN): BOOLEAN; }
  177.     TEFindWordProcPtr = ProcPtr;  { PROCEDURE TEFindWord(currentPos: INTEGER; caller: INTEGER; pTE: TEPtr; hTE: TEHandle; VAR wordStart: INTEGER; VAR wordEnd: INTEGER); }
  178.     TERecalcProcPtr = ProcPtr;  { PROCEDURE TERecalc(pTE: TEPtr; changeLength: INTEGER; VAR lineStart: INTEGER; VAR firstChar: INTEGER; VAR lastChar: INTEGER); }
  179.     TEDoTextProcPtr = ProcPtr;  { PROCEDURE TEDoText(pTE: TEPtr; firstChar: INTEGER; lastChar: INTEGER; selector: INTEGER; VAR currentGrafPort: GrafPtr; VAR charPosition: INTEGER); }
  180.     {
  181.         TEClickLoopProcPtr uses register based parameters on the 68k and cannot
  182.         be written in or called from a high-level language without the help of
  183.         mixed mode or assembly glue.
  184.  
  185.         In:
  186.          => pTE             A3.L
  187.         Out:
  188.          <= return value    Z bit of Status Register
  189.     }
  190.     TEClickLoopProcPtr = ProcPtr;  { FUNCTION TEClickLoop(pTE: TEPtr): BOOLEAN; }
  191.     {
  192.         WordBreakProcPtr uses register based parameters on the 68k and cannot
  193.         be written in or called from a high-level language without the help of
  194.         mixed mode or assembly glue.
  195.  
  196.         In:
  197.          => text            A0.L
  198.          => charPos         D0.W
  199.         Out:
  200.          <= return value    Z bit of Status Register
  201.     }
  202.     WordBreakProcPtr = ProcPtr;  { FUNCTION WordBreak(text: Ptr; charPos: INTEGER): BOOLEAN; }
  203.     HighHookUPP = UniversalProcPtr;
  204.     EOLHookUPP = UniversalProcPtr;
  205.     CaretHookUPP = UniversalProcPtr;
  206.     WidthHookUPP = UniversalProcPtr;
  207.     TextWidthHookUPP = UniversalProcPtr;
  208.     NWidthHookUPP = UniversalProcPtr;
  209.     DrawHookUPP = UniversalProcPtr;
  210.     HitTestHookUPP = UniversalProcPtr;
  211.     TEFindWordUPP = UniversalProcPtr;
  212.     TERecalcUPP = UniversalProcPtr;
  213.     TEDoTextUPP = UniversalProcPtr;
  214.     TEClickLoopUPP = UniversalProcPtr;
  215.     WordBreakUPP = UniversalProcPtr;
  216.  
  217.     TERec = RECORD
  218.         destRect:                Rect;
  219.         viewRect:                Rect;
  220.         selRect:                Rect;
  221.         lineHeight:                INTEGER;
  222.         fontAscent:                INTEGER;
  223.         selPoint:                Point;
  224.         selStart:                INTEGER;
  225.         selEnd:                    INTEGER;
  226.         active:                    INTEGER;
  227.         wordBreak:                WordBreakUPP;
  228.         clickLoop:                TEClickLoopUPP;
  229.         clickTime:                LONGINT;
  230.         clickLoc:                INTEGER;
  231.         caretTime:                LONGINT;
  232.         caretState:                INTEGER;
  233.         just:                    INTEGER;
  234.         teLength:                INTEGER;
  235.         hText:                    Handle;
  236.         hDispatchRec:            LONGINT;                                { added to replace recalBack & recalLines.  it's a handle anyway }
  237.         clikStuff:                INTEGER;
  238.         crOnly:                    INTEGER;
  239.         txFont:                    INTEGER;
  240.         txFace:                    Style;                                    {txFace is unpacked byte}
  241.         txMode:                    INTEGER;
  242.         txSize:                    INTEGER;
  243.         inPort:                    GrafPtr;
  244.         highHook:                HighHookUPP;
  245.         caretHook:                CaretHookUPP;
  246.         nLines:                    INTEGER;
  247.         lineStarts:                ARRAY [0..16000] OF INTEGER;
  248.     END;
  249.  
  250. CONST
  251. { Justification (word alignment) styles }
  252.     teJustLeft                    = 0;
  253.     teJustCenter                = 1;
  254.     teJustRight                    = -1;
  255.     teForceLeft                    = -2;
  256. { new names for the Justification (word alignment) styles }
  257.     teFlushDefault                = 0;                            {flush according to the line direction }
  258.     teCenter                    = 1;                            {center justify (word alignment) }
  259.     teFlushRight                = -1;                            {flush right for all scripts }
  260.     teFlushLeft                    = -2;                            {flush left for all scripts }
  261. { Set/Replace style modes }
  262.     fontBit                        = 0;                            {set font}
  263.     faceBit                        = 1;                            {set face}
  264.     sizeBit                        = 2;                            {set size}
  265.     clrBit                        = 3;                            {set color}
  266.     addSizeBit                    = 4;                            {add size mode}
  267.     toggleBit                    = 5;                            {set faces in toggle mode}
  268.     toglBit                        = 5;                            { obsolete.  use toggleBit }
  269. { TESetStyle/TEContinuousStyle modes }
  270.     doFont                        = 1;                            { set font (family) number}
  271.     doFace                        = 2;                            {set character style}
  272.     doSize                        = 4;                            {set type size}
  273.     doColor                        = 8;                            {set color}
  274.     doAll                        = 15;                            {set all attributes}
  275.     addSize                        = 16;                            {adjust type size}
  276.  
  277.     doToggle                    = 32;                            {toggle mode for TESetStyle}
  278. { offsets into TEDispatchRec }
  279.     EOLHook                        = 0;                            {[UniversalProcPtr] TEEOLHook}
  280.     DRAWHook                    = 4;                            {[UniversalProcPtr] TEWidthHook}
  281.     WIDTHHook                    = 8;                            {[UniversalProcPtr] TEDrawHook}
  282.     HITTESTHook                    = 12;                            {[UniversalProcPtr] TEHitTestHook}
  283.     nWIDTHHook                    = 24;                            {[UniversalProcPtr] nTEWidthHook}
  284.     TextWidthHook                = 28;                            {[UniversalProcPtr] TETextWidthHook}
  285. { selectors for TECustomHook }
  286.     intEOLHook                    = 0;                            {TEIntHook value}
  287.     intDrawHook                    = 1;                            {TEIntHook value}
  288.     intWidthHook                = 2;                            {TEIntHook value}
  289.     intHitTestHook                = 3;                            {TEIntHook value}
  290.     intNWidthHook                = 6;                            {TEIntHook value for new version of WidthHook}
  291.     intTextWidthHook            = 7;                            {TEIntHook value for new TextWidthHook}
  292. { feature or bit definitions for TEFeatureFlag }
  293.     teFAutoScroll                = 0;                            {00000001b}
  294.     teFAutoScr                    = 0;                            {00000001b  obsolete. use teFAutoScroll}
  295.     teFTextBuffering            = 1;                            {00000010b}
  296.     teFOutlineHilite            = 2;                            {00000100b}
  297.     teFInlineInput                = 3;                            {00001000b }
  298.     teFUseTextServices            = 4;                            {00010000b }
  299.  
  300. { action for the new "bit (un)set" interface, TEFeatureFlag }
  301.     teBitClear                    = 0;
  302.     teBitSet                    = 1;                            {set the selector bit}
  303.     teBitTest                    = -1;                            {no change; just return the current setting}
  304. {constants for identifying the routine that called FindWord }
  305.     teWordSelect                = 4;                            {clickExpand to select word}
  306.     teWordDrag                    = 8;                            {clickExpand to drag new word}
  307.     teFromFind                    = 12;                            {FindLine called it ($0C)}
  308.     teFromRecal                    = 16;                            {RecalLines called it ($10)      obsolete }
  309. {constants for identifying TEDoText selectors }
  310.     teFind                        = 0;                            {TEDoText called for searching}
  311.     teHighlight                    = 1;                            {TEDoText called for highlighting}
  312.     teDraw                        = -1;                            {TEDoText called for drawing text}
  313.     teCaret                        = -2;                            {TEDoText called for drawing the caret}
  314.  
  315.     
  316. TYPE
  317.     Chars = PACKED ARRAY [0..32000] OF CHAR;
  318.  
  319.     CharsPtr = ^Chars;
  320.  
  321.     CharsHandle = ^CharsPtr;
  322.  
  323.     StyleRun = RECORD
  324.         startChar:                INTEGER;                                {starting character position}
  325.         styleIndex:                INTEGER;                                {index in style table}
  326.     END;
  327.     STElement = RECORD
  328.         stCount:                INTEGER;                                {number of runs in this style}
  329.         stHeight:                INTEGER;                                {line height}
  330.         stAscent:                INTEGER;                                {font ascent}
  331.         stFont:                    INTEGER;                                {font (family) number}
  332.         stFace:                    Style;                                    {character Style}
  333.         stSize:                    INTEGER;                                {size in points}
  334.         stColor:                RGBColor;                                {absolute (RGB) color}
  335.     END;
  336.     TEStyleTable = ARRAY [0..1776] OF STElement;
  337.  
  338.     STPtr = ^TEStyleTable;
  339.     STHandle = ^STPtr;
  340.  
  341.     LHElement = RECORD
  342.         lhHeight:                INTEGER;                                {maximum height in line}
  343.         lhAscent:                INTEGER;                                {maximum ascent in line}
  344.     END;
  345.     LHTable = ARRAY [0..8000] OF LHElement;
  346.  
  347.     LHPtr = ^LHTable;
  348.     LHHandle = ^LHPtr;
  349.  
  350.     ScrpSTElement = RECORD
  351.         scrpStartChar:            LONGINT;                                {starting character position}
  352.         scrpHeight:                INTEGER;                                {starting character position}
  353.         scrpAscent:                INTEGER;
  354.         scrpFont:                INTEGER;
  355.         scrpFace:                Style;                                    {unpacked byte}
  356.         scrpSize:                INTEGER;
  357.         scrpColor:                RGBColor;
  358.     END;
  359. { ARRAY [0..1600] OF ScrpSTElement }
  360.     ScrpSTTable = ARRAY [0..1600] OF ScrpSTElement;
  361.  
  362.     StScrpRec = RECORD
  363.         scrpNStyles:            INTEGER;                                {number of styles in scrap}
  364.         scrpStyleTab:            ScrpSTTable;                            {table of styles for scrap}
  365.     END;
  366.     StScrpPtr = ^StScrpRec;
  367.     StScrpHandle = ^StScrpPtr;
  368.  
  369.     NullStRec = RECORD
  370.         teReserved:                LONGINT;                                {reserved for future expansion}
  371.         nullScrap:                StScrpHandle;                            {handle to scrap style table}
  372.     END;
  373.     NullStPtr = ^NullStRec;
  374.     NullStHandle = ^NullStPtr;
  375.  
  376.     TEStyleRec = RECORD
  377.         nRuns:                    INTEGER;                                {number of style runs}
  378.         nStyles:                INTEGER;                                {size of style table}
  379.         styleTab:                STHandle;                                {handle to style table}
  380.         lhTab:                    LHHandle;                                {handle to line-height table}
  381.         teRefCon:                LONGINT;                                {reserved for application use}
  382.         nullStyle:                NullStHandle;                            {Handle to style set at null selection}
  383.         runs:                    ARRAY [0..8000] OF StyleRun;            {ARRAY [0..8000] OF StyleRun}
  384.     END;
  385.     TEStylePtr = ^TEStyleRec;
  386.     TEStyleHandle = ^TEStylePtr;
  387.  
  388.     TextStyle = RECORD
  389.         tsFont:                    INTEGER;                                {font (family) number}
  390.         tsFace:                    Style;                                    {character Style}
  391.         tsSize:                    INTEGER;                                {size in point}
  392.         tsColor:                RGBColor;                                {absolute (RGB) color}
  393.     END;
  394.     TextStylePtr = ^TextStyle;
  395.     TextStyleHandle = ^TextStylePtr;
  396.  
  397.     TEIntHook = INTEGER;
  398.  
  399.  
  400. CONST
  401.     uppHighHookProcInfo = $0000000F; { SPECIAL_CASE_PROCINFO( kSpecialCaseHighHook ) }
  402.     uppEOLHookProcInfo = $0000001F; { SPECIAL_CASE_PROCINFO( kSpecialCaseEOLHook ) }
  403.     uppCaretHookProcInfo = $0000000F; { SPECIAL_CASE_PROCINFO( kSpecialCaseCaretHook ) }
  404.     uppWidthHookProcInfo = $0000002F; { SPECIAL_CASE_PROCINFO( kSpecialCaseWidthHook ) }
  405.     uppTextWidthHookProcInfo = $0000002F; { SPECIAL_CASE_PROCINFO( kSpecialCaseTextWidthHook ) }
  406.     uppNWidthHookProcInfo = $0000003F; { SPECIAL_CASE_PROCINFO( kSpecialCaseNWidthHook ) }
  407.     uppDrawHookProcInfo = $0000004F; { SPECIAL_CASE_PROCINFO( kSpecialCaseDrawHook ) }
  408.     uppHitTestHookProcInfo = $0000005F; { SPECIAL_CASE_PROCINFO( kSpecialCaseHitTestHook ) }
  409.     uppTEFindWordProcInfo = $0000006F; { SPECIAL_CASE_PROCINFO( kSpecialCaseTEFindWord ) }
  410.     uppTERecalcProcInfo = $0000009F; { SPECIAL_CASE_PROCINFO( kSpecialCaseTERecalc ) }
  411.     uppTEDoTextProcInfo = $000000AF; { SPECIAL_CASE_PROCINFO( kSpecialCaseTEDoText ) }
  412.     uppTEClickLoopProcInfo = $0000FC82; { Register FUNCTION (4 bytes in A3): Z bit of Status Register; }
  413.     uppWordBreakProcInfo = $00029C82; { Register FUNCTION (4 bytes in A0, 2 bytes in D0): Z bit of Status Register; }
  414.  
  415. FUNCTION NewHighHookProc(userRoutine: HighHookProcPtr): HighHookUPP;
  416.     {$IFC NOT GENERATINGCFM }
  417.     INLINE $2E9F;
  418.     {$ENDC}
  419.  
  420. FUNCTION NewEOLHookProc(userRoutine: EOLHookProcPtr): EOLHookUPP;
  421.     {$IFC NOT GENERATINGCFM }
  422.     INLINE $2E9F;
  423.     {$ENDC}
  424.  
  425. FUNCTION NewCaretHookProc(userRoutine: CaretHookProcPtr): CaretHookUPP;
  426.     {$IFC NOT GENERATINGCFM }
  427.     INLINE $2E9F;
  428.     {$ENDC}
  429.  
  430. FUNCTION NewWidthHookProc(userRoutine: WidthHookProcPtr): WidthHookUPP;
  431.     {$IFC NOT GENERATINGCFM }
  432.     INLINE $2E9F;
  433.     {$ENDC}
  434.  
  435. FUNCTION NewTextWidthHookProc(userRoutine: TextWidthHookProcPtr): TextWidthHookUPP;
  436.     {$IFC NOT GENERATINGCFM }
  437.     INLINE $2E9F;
  438.     {$ENDC}
  439.  
  440. FUNCTION NewNWidthHookProc(userRoutine: NWidthHookProcPtr): NWidthHookUPP;
  441.     {$IFC NOT GENERATINGCFM }
  442.     INLINE $2E9F;
  443.     {$ENDC}
  444.  
  445. FUNCTION NewDrawHookProc(userRoutine: DrawHookProcPtr): DrawHookUPP;
  446.     {$IFC NOT GENERATINGCFM }
  447.     INLINE $2E9F;
  448.     {$ENDC}
  449.  
  450. FUNCTION NewHitTestHookProc(userRoutine: HitTestHookProcPtr): HitTestHookUPP;
  451.     {$IFC NOT GENERATINGCFM }
  452.     INLINE $2E9F;
  453.     {$ENDC}
  454.  
  455. FUNCTION NewTEFindWordProc(userRoutine: TEFindWordProcPtr): TEFindWordUPP;
  456.     {$IFC NOT GENERATINGCFM }
  457.     INLINE $2E9F;
  458.     {$ENDC}
  459.  
  460. FUNCTION NewTERecalcProc(userRoutine: TERecalcProcPtr): TERecalcUPP;
  461.     {$IFC NOT GENERATINGCFM }
  462.     INLINE $2E9F;
  463.     {$ENDC}
  464.  
  465. FUNCTION NewTEDoTextProc(userRoutine: TEDoTextProcPtr): TEDoTextUPP;
  466.     {$IFC NOT GENERATINGCFM }
  467.     INLINE $2E9F;
  468.     {$ENDC}
  469.  
  470. FUNCTION NewTEClickLoopProc(userRoutine: TEClickLoopProcPtr): TEClickLoopUPP;
  471.     {$IFC NOT GENERATINGCFM }
  472.     INLINE $2E9F;
  473.     {$ENDC}
  474.  
  475. FUNCTION NewWordBreakProc(userRoutine: WordBreakProcPtr): WordBreakUPP;
  476.     {$IFC NOT GENERATINGCFM }
  477.     INLINE $2E9F;
  478.     {$ENDC}
  479.  
  480. PROCEDURE CallHighHookProc({CONST}VAR r: Rect; pTE: TEPtr; userRoutine: HighHookUPP);
  481.     {$IFC NOT GENERATINGCFM}
  482.     {To be implemented:  Glue to move parameters according to special case conventions.}
  483.     {$ENDC}
  484.  
  485. FUNCTION CallEOLHookProc(theChar: ByteParameter; pTE: TEPtr; hTE: TEHandle; userRoutine: EOLHookUPP): BOOLEAN;
  486.     {$IFC NOT GENERATINGCFM}
  487.     {To be implemented:  Glue to move parameters according to special case conventions.}
  488.     {$ENDC}
  489.  
  490. PROCEDURE CallCaretHookProc({CONST}VAR r: Rect; pTE: TEPtr; userRoutine: CaretHookUPP);
  491.     {$IFC NOT GENERATINGCFM}
  492.     {To be implemented:  Glue to move parameters according to special case conventions.}
  493.     {$ENDC}
  494.  
  495. FUNCTION CallWidthHookProc(textLen: INTEGER; textOffset: INTEGER; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle; userRoutine: WidthHookUPP): INTEGER;
  496.     {$IFC NOT GENERATINGCFM}
  497.     {To be implemented:  Glue to move parameters according to special case conventions.}
  498.     {$ENDC}
  499.  
  500. FUNCTION CallTextWidthHookProc(textLen: INTEGER; textOffset: INTEGER; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle; userRoutine: TextWidthHookUPP): INTEGER;
  501.     {$IFC NOT GENERATINGCFM}
  502.     {To be implemented:  Glue to move parameters according to special case conventions.}
  503.     {$ENDC}
  504.  
  505. FUNCTION CallNWidthHookProc(styleRunLen: INTEGER; styleRunOffset: INTEGER; slop: INTEGER; direction: INTEGER; textBufferPtr: UNIV Ptr; VAR lineStart: INTEGER; pTE: TEPtr; hTE: TEHandle; userRoutine: NWidthHookUPP): INTEGER;
  506.     {$IFC NOT GENERATINGCFM}
  507.     {To be implemented:  Glue to move parameters according to special case conventions.}
  508.     {$ENDC}
  509.  
  510. PROCEDURE CallDrawHookProc(textOffset: INTEGER; drawLen: INTEGER; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle; userRoutine: DrawHookUPP);
  511.     {$IFC NOT GENERATINGCFM}
  512.     {To be implemented:  Glue to move parameters according to special case conventions.}
  513.     {$ENDC}
  514.  
  515. FUNCTION CallHitTestHookProc(styleRunLen: INTEGER; styleRunOffset: INTEGER; slop: INTEGER; textBufferPtr: UNIV Ptr; pTE: TEPtr; hTE: TEHandle; VAR pixelWidth: INTEGER; VAR charOffset: INTEGER; VAR pixelInChar: BOOLEAN; userRoutine: HitTestHookUPP): BOOLEAN;
  516.     {$IFC NOT GENERATINGCFM}
  517.     {To be implemented:  Glue to move parameters according to special case conventions.}
  518.     {$ENDC}
  519.  
  520. PROCEDURE CallTEFindWordProc(currentPos: INTEGER; caller: INTEGER; pTE: TEPtr; hTE: TEHandle; VAR wordStart: INTEGER; VAR wordEnd: INTEGER; userRoutine: TEFindWordUPP);
  521.     {$IFC NOT GENERATINGCFM}
  522.     {To be implemented:  Glue to move parameters according to special case conventions.}
  523.     {$ENDC}
  524.  
  525. PROCEDURE CallTERecalcProc(pTE: TEPtr; changeLength: INTEGER; VAR lineStart: INTEGER; VAR firstChar: INTEGER; VAR lastChar: INTEGER; userRoutine: TERecalcUPP);
  526.     {$IFC NOT GENERATINGCFM}
  527.     {To be implemented:  Glue to move parameters according to special case conventions.}
  528.     {$ENDC}
  529.  
  530. PROCEDURE CallTEDoTextProc(pTE: TEPtr; firstChar: INTEGER; lastChar: INTEGER; selector: INTEGER; VAR currentGrafPort: GrafPtr; VAR charPosition: INTEGER; userRoutine: TEDoTextUPP);
  531.     {$IFC NOT GENERATINGCFM}
  532.     {To be implemented:  Glue to move parameters according to special case conventions.}
  533.     {$ENDC}
  534.  
  535. FUNCTION CallTEClickLoopProc(pTE: TEPtr; userRoutine: TEClickLoopUPP): BOOLEAN;
  536.     {$IFC NOT GENERATINGCFM}
  537.     {To be implemented:  Glue to move parameters into registers.}
  538.     {$ENDC}
  539.  
  540. FUNCTION CallWordBreakProc(text: Ptr; charPos: INTEGER; userRoutine: WordBreakUPP): BOOLEAN;
  541.     {$IFC NOT GENERATINGCFM}
  542.     {To be implemented:  Glue to move parameters into registers.}
  543.     {$ENDC}
  544. FUNCTION TEScrapHandle : Handle;
  545.     {$IFC NOT CFMSYSTEMCALLS}
  546.     INLINE $2EB8, $0AB4;            { MOVE.L $0AB4,(SP) }
  547.     {$ENDC}
  548.  
  549. FUNCTION TEGetScrapLength: LONGINT;
  550. PROCEDURE TEInit;
  551.     {$IFC NOT GENERATINGCFM}
  552.     INLINE $A9CC;
  553.     {$ENDC}
  554. FUNCTION TENew({CONST}VAR destRect: Rect; {CONST}VAR viewRect: Rect): TEHandle;
  555.     {$IFC NOT GENERATINGCFM}
  556.     INLINE $A9D2;
  557.     {$ENDC}
  558. PROCEDURE TEDispose(hTE: TEHandle);
  559.     {$IFC NOT GENERATINGCFM}
  560.     INLINE $A9CD;
  561.     {$ENDC}
  562. PROCEDURE TESetText(text: UNIV Ptr; length: LONGINT; hTE: TEHandle);
  563.     {$IFC NOT GENERATINGCFM}
  564.     INLINE $A9CF;
  565.     {$ENDC}
  566. FUNCTION TEGetText(hTE: TEHandle): CharsHandle;
  567.     {$IFC NOT GENERATINGCFM}
  568.     INLINE $A9CB;
  569.     {$ENDC}
  570. PROCEDURE TEIdle(hTE: TEHandle);
  571.     {$IFC NOT GENERATINGCFM}
  572.     INLINE $A9DA;
  573.     {$ENDC}
  574. PROCEDURE TESetSelect(selStart: LONGINT; selEnd: LONGINT; hTE: TEHandle);
  575.     {$IFC NOT GENERATINGCFM}
  576.     INLINE $A9D1;
  577.     {$ENDC}
  578. PROCEDURE TEActivate(hTE: TEHandle);
  579.     {$IFC NOT GENERATINGCFM}
  580.     INLINE $A9D8;
  581.     {$ENDC}
  582. PROCEDURE TEDeactivate(hTE: TEHandle);
  583.     {$IFC NOT GENERATINGCFM}
  584.     INLINE $A9D9;
  585.     {$ENDC}
  586. PROCEDURE TEKey(key: CHAR; hTE: TEHandle);
  587.     {$IFC NOT GENERATINGCFM}
  588.     INLINE $A9DC;
  589.     {$ENDC}
  590. PROCEDURE TECut(hTE: TEHandle);
  591.     {$IFC NOT GENERATINGCFM}
  592.     INLINE $A9D6;
  593.     {$ENDC}
  594. PROCEDURE TECopy(hTE: TEHandle);
  595.     {$IFC NOT GENERATINGCFM}
  596.     INLINE $A9D5;
  597.     {$ENDC}
  598. PROCEDURE TEPaste(hTE: TEHandle);
  599.     {$IFC NOT GENERATINGCFM}
  600.     INLINE $A9DB;
  601.     {$ENDC}
  602. PROCEDURE TEDelete(hTE: TEHandle);
  603.     {$IFC NOT GENERATINGCFM}
  604.     INLINE $A9D7;
  605.     {$ENDC}
  606. PROCEDURE TEInsert(text: UNIV Ptr; length: LONGINT; hTE: TEHandle);
  607.     {$IFC NOT GENERATINGCFM}
  608.     INLINE $A9DE;
  609.     {$ENDC}
  610. PROCEDURE TESetAlignment(just: INTEGER; hTE: TEHandle);
  611.     {$IFC NOT GENERATINGCFM}
  612.     INLINE $A9DF;
  613.     {$ENDC}
  614. PROCEDURE TEUpdate({CONST}VAR rUpdate: Rect; hTE: TEHandle);
  615.     {$IFC NOT GENERATINGCFM}
  616.     INLINE $A9D3;
  617.     {$ENDC}
  618. PROCEDURE TETextBox(text: UNIV Ptr; length: LONGINT; {CONST}VAR box: Rect; just: INTEGER);
  619.     {$IFC NOT GENERATINGCFM}
  620.     INLINE $A9CE;
  621.     {$ENDC}
  622. PROCEDURE TEScroll(dh: INTEGER; dv: INTEGER; hTE: TEHandle);
  623.     {$IFC NOT GENERATINGCFM}
  624.     INLINE $A9DD;
  625.     {$ENDC}
  626. PROCEDURE TESelView(hTE: TEHandle);
  627.     {$IFC NOT GENERATINGCFM}
  628.     INLINE $A811;
  629.     {$ENDC}
  630. PROCEDURE TEPinScroll(dh: INTEGER; dv: INTEGER; hTE: TEHandle);
  631.     {$IFC NOT GENERATINGCFM}
  632.     INLINE $A812;
  633.     {$ENDC}
  634. PROCEDURE TEAutoView(fAuto: BOOLEAN; hTE: TEHandle);
  635.     {$IFC NOT GENERATINGCFM}
  636.     INLINE $A813;
  637.     {$ENDC}
  638. PROCEDURE TECalText(hTE: TEHandle);
  639.     {$IFC NOT GENERATINGCFM}
  640.     INLINE $A9D0;
  641.     {$ENDC}
  642. FUNCTION TEGetOffset(pt: Point; hTE: TEHandle): INTEGER;
  643.     {$IFC NOT GENERATINGCFM}
  644.     INLINE $A83C;
  645.     {$ENDC}
  646. FUNCTION TEGetPoint(offset: INTEGER; hTE: TEHandle): Point;
  647.     {$IFC NOT GENERATINGCFM}
  648.     INLINE $3F3C, $0008, $A83D;
  649.     {$ENDC}
  650. PROCEDURE TEClick(pt: Point; fExtend: BOOLEAN; h: TEHandle);
  651.     {$IFC NOT GENERATINGCFM}
  652.     INLINE $A9D4;
  653.     {$ENDC}
  654. FUNCTION TEStyleNew({CONST}VAR destRect: Rect; {CONST}VAR viewRect: Rect): TEHandle;
  655.     {$IFC NOT GENERATINGCFM}
  656.     INLINE $A83E;
  657.     {$ENDC}
  658. PROCEDURE TESetStyleHandle(theHandle: TEStyleHandle; hTE: TEHandle);
  659.     {$IFC NOT GENERATINGCFM}
  660.     INLINE $3F3C, $0005, $A83D;
  661.     {$ENDC}
  662. FUNCTION TEGetStyleHandle(hTE: TEHandle): TEStyleHandle;
  663.     {$IFC NOT GENERATINGCFM}
  664.     INLINE $3F3C, $0004, $A83D;
  665.     {$ENDC}
  666. PROCEDURE TEGetStyle(offset: INTEGER; VAR theStyle: TextStyle; VAR lineHeight: INTEGER; VAR fontAscent: INTEGER; hTE: TEHandle);
  667.     {$IFC NOT GENERATINGCFM}
  668.     INLINE $3F3C, $0003, $A83D;
  669.     {$ENDC}
  670. PROCEDURE TEStylePaste(hTE: TEHandle);
  671.     {$IFC NOT GENERATINGCFM}
  672.     INLINE $3F3C, $0000, $A83D;
  673.     {$ENDC}
  674. PROCEDURE TESetStyle(mode: INTEGER; {CONST}VAR newStyle: TextStyle; fRedraw: BOOLEAN; hTE: TEHandle);
  675.     {$IFC NOT GENERATINGCFM}
  676.     INLINE $3F3C, $0001, $A83D;
  677.     {$ENDC}
  678. PROCEDURE TEReplaceStyle(mode: INTEGER; {CONST}VAR oldStyle: TextStyle; {CONST}VAR newStyle: TextStyle; fRedraw: BOOLEAN; hTE: TEHandle);
  679.     {$IFC NOT GENERATINGCFM}
  680.     INLINE $3F3C, $0002, $A83D;
  681.     {$ENDC}
  682. FUNCTION TEGetStyleScrapHandle(hTE: TEHandle): StScrpHandle;
  683.     {$IFC NOT GENERATINGCFM}
  684.     INLINE $3F3C, $0006, $A83D;
  685.     {$ENDC}
  686. PROCEDURE TEStyleInsert(text: UNIV Ptr; length: LONGINT; hST: StScrpHandle; hTE: TEHandle);
  687.     {$IFC NOT GENERATINGCFM}
  688.     INLINE $3F3C, $0007, $A83D;
  689.     {$ENDC}
  690. FUNCTION TEGetHeight(endLine: LONGINT; startLine: LONGINT; hTE: TEHandle): LONGINT;
  691.     {$IFC NOT GENERATINGCFM}
  692.     INLINE $3F3C, $0009, $A83D;
  693.     {$ENDC}
  694. FUNCTION TEContinuousStyle(VAR mode: INTEGER; VAR aStyle: TextStyle; hTE: TEHandle): BOOLEAN;
  695.     {$IFC NOT GENERATINGCFM}
  696.     INLINE $3F3C, $000A, $A83D;
  697.     {$ENDC}
  698. PROCEDURE TEUseStyleScrap(rangeStart: LONGINT; rangeEnd: LONGINT; newStyles: StScrpHandle; fRedraw: BOOLEAN; hTE: TEHandle);
  699.     {$IFC NOT GENERATINGCFM}
  700.     INLINE $3F3C, $000B, $A83D;
  701.     {$ENDC}
  702. PROCEDURE TECustomHook(which: TEIntHook; VAR addr: UniversalProcPtr; hTE: TEHandle);
  703.     {$IFC NOT GENERATINGCFM}
  704.     INLINE $3F3C, $000C, $A83D;
  705.     {$ENDC}
  706. FUNCTION TENumStyles(rangeStart: LONGINT; rangeEnd: LONGINT; hTE: TEHandle): LONGINT;
  707.     {$IFC NOT GENERATINGCFM}
  708.     INLINE $3F3C, $000D, $A83D;
  709.     {$ENDC}
  710. FUNCTION TEFeatureFlag(feature: INTEGER; action: INTEGER; hTE: TEHandle): INTEGER;
  711.     {$IFC NOT GENERATINGCFM}
  712.     INLINE $3F3C, $000E, $A83D;
  713.     {$ENDC}
  714. FUNCTION TEGetHiliteRgn(region: RgnHandle; hTE: TEHandle): OSErr;
  715.     {$IFC NOT GENERATINGCFM}
  716.     INLINE $3F3C, $000F, $A83D;
  717.     {$ENDC}
  718. PROCEDURE TESetScrapLength(length: LONGINT);
  719. FUNCTION TEFromScrap: OSErr;
  720. FUNCTION TEToScrap: OSErr;
  721. PROCEDURE TESetClickLoop(clikProc: TEClickLoopUPP; hTE: TEHandle);
  722. PROCEDURE TESetWordBreak(wBrkProc: WordBreakUPP; hTE: TEHandle);
  723. {$IFC OLDROUTINENAMES }
  724. PROCEDURE TESetJust(just: INTEGER; hTE: TEHandle);
  725.     {$IFC NOT GENERATINGCFM}
  726.     INLINE $A9DF;
  727.     {$ENDC}
  728. PROCEDURE TextBox(text: UNIV Ptr; length: LONGINT; {CONST}VAR box: Rect; just: INTEGER);
  729.     {$IFC NOT GENERATINGCFM}
  730.     INLINE $A9CE;
  731.     {$ENDC}
  732. FUNCTION TEStylNew({CONST}VAR destRect: Rect; {CONST}VAR viewRect: Rect): TEHandle;
  733.     {$IFC NOT GENERATINGCFM}
  734.     INLINE $A83E;
  735.     {$ENDC}
  736. PROCEDURE SetStylHandle(theHandle: TEStyleHandle; hTE: TEHandle);
  737.     {$IFC NOT GENERATINGCFM}
  738.     INLINE $3F3C, $0005, $A83D;
  739.     {$ENDC}
  740. PROCEDURE SetStyleHandle(theHandle: TEStyleHandle; hTE: TEHandle);
  741.     {$IFC NOT GENERATINGCFM}
  742.     INLINE $3F3C, $0005, $A83D;
  743.     {$ENDC}
  744. FUNCTION GetStylHandle(hTE: TEHandle): TEStyleHandle;
  745.     {$IFC NOT GENERATINGCFM}
  746.     INLINE $3F3C, $0004, $A83D;
  747.     {$ENDC}
  748. FUNCTION GetStyleHandle(hTE: TEHandle): TEStyleHandle;
  749.     {$IFC NOT GENERATINGCFM}
  750.     INLINE $3F3C, $0004, $A83D;
  751.     {$ENDC}
  752. PROCEDURE TEStylPaste(hTE: TEHandle);
  753.     {$IFC NOT GENERATINGCFM}
  754.     INLINE $3F3C, $0000, $A83D;
  755.     {$ENDC}
  756. FUNCTION GetStylScrap(hTE: TEHandle): StScrpHandle;
  757.     {$IFC NOT GENERATINGCFM}
  758.     INLINE $3F3C, $0006, $A83D;
  759.     {$ENDC}
  760. FUNCTION GetStyleScrap(hTE: TEHandle): StScrpHandle;
  761.     {$IFC NOT GENERATINGCFM}
  762.     INLINE $3F3C, $0006, $A83D;
  763.     {$ENDC}
  764. PROCEDURE SetStylScrap(rangeStart: LONGINT; rangeEnd: LONGINT; newStyles: StScrpHandle; fRedraw: BOOLEAN; hTE: TEHandle);
  765.     {$IFC NOT GENERATINGCFM}
  766.     INLINE $3F3C, $000B, $A83D;
  767.     {$ENDC}
  768. PROCEDURE SetStyleScrap(rangeStart: LONGINT; rangeEnd: LONGINT; newStyles: StScrpHandle; fRedraw: BOOLEAN; hTE: TEHandle);
  769.     {$IFC NOT GENERATINGCFM}
  770.     INLINE $3F3C, $000B, $A83D;
  771.     {$ENDC}
  772. PROCEDURE TEStylInsert(text: UNIV Ptr; length: LONGINT; hST: StScrpHandle; hTE: TEHandle);
  773.     {$IFC NOT GENERATINGCFM}
  774.     INLINE $3F3C, $0007, $A83D;
  775.     {$ENDC}
  776. PROCEDURE TESetScrapLen(length: LONGINT);
  777. FUNCTION TEGetScrapLen: LONGINT;
  778. PROCEDURE SetClikLoop(clikProc: TEClickLoopUPP; hTE: TEHandle);
  779. PROCEDURE SetWordBreak(wBrkProc: WordBreakUPP; hTE: TEHandle);
  780. {$ENDC}
  781.  
  782. {$ALIGN RESET}
  783. {$POP}
  784.  
  785. {$SETC UsingIncludes := TextEditIncludes}
  786.  
  787. {$ENDC} {__TEXTEDIT__}
  788.  
  789. {$IFC NOT UsingIncludes}
  790.  END.
  791. {$ENDC}
  792.